package com.melody.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.melody.entry.MusicCount;
import com.melody.entry.MusicInfo;
import com.melody.entry.MusicLabel;
import com.melody.mapper.MusicCountMapper;
import com.melody.mapper.MusicLabelMapper;
import com.melody.model.convert.MusicDetailsConvert;
import com.melody.model.vo.MusicDetailsVo;
import com.melody.service.MusicInfoService;
import com.melody.mapper.MusicInfoMapper;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * MusicInfoServiceImpl类实现了MusicInfoService接口，负责对歌曲信息表（music_info）进行数据库操作。
 * @author zxz
 * @description 针对表【music_info(歌曲信息表)】的数据库操作Service实现
 * @createDate 2025-05-09 10:31:17
 */
@Service
public class MusicInfoServiceImpl extends ServiceImpl<MusicInfoMapper, MusicInfo> implements MusicInfoService {
    @Autowired
    private MusicInfoMapper musicInfoMapper; // 注入MusicInfoMapper
    @Autowired
    private MusicLabelMapper musicLabelMapper;
    @Autowired
    private MusicCountMapper musicCountMapper;

    /**
     * 根据音乐ID列表查询音乐信息。
     * @param musicIds 音乐ID列表
     * @return List<MusicInfo> 查询到的音乐信息列表
     */
    @Override
    public List<MusicInfo> getMusicsByListId(List<Integer> musicIds) {
        // 构建查询条件
        QueryWrapper<MusicInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("music_id", musicIds) // 指定音乐ID列表
                    .orderByDesc("create_time");

        // 查询记录
        return musicInfoMapper.selectList(queryWrapper); // 返回查询到的音乐信息列表
    }




    /**
     * 根据音乐id查询音乐信息（包括音乐标签）
     * @param musicId 音乐ID
     * @return MusicDetailsVo 包含音乐详细信息的对象
     */
    @Override
    public MusicDetailsVo findMusicById(Integer musicId) {
        // 根据音乐ID查询音乐基础信息
        MusicInfo musicInfo = musicInfoMapper.findMusicById(musicId);

        // 根据查询到的音乐信息中的标签ID查询对应的音乐标签信息
        MusicLabel musicLabel = musicLabelMapper.findLabelById(musicInfo.getLabelId());

        // 创建MusicDetailsVo对象，用于封装音乐详细信息
        MusicDetailsVo musicDetailsVo = new MusicDetailsVo();
        // 将音乐基础信息设置到MusicDetailsVo对象中
        musicDetailsVo.setMusicId(musicInfo.getMusicId());
        musicDetailsVo.setMusicImg(musicInfo.getMusicImg());
        musicDetailsVo.setMusicUrl(musicInfo.getMusicUrl());
        musicDetailsVo.setMusicName(musicInfo.getMusicName());
        musicDetailsVo.setSinger(musicInfo.getSinger());
        musicDetailsVo.setMusicTime(musicInfo.getMusicTime());
        musicDetailsVo.setCreateTime(musicInfo.getCreateTime());
        musicDetailsVo.setUpdateTime(musicInfo.getUpdateTime());
        musicDetailsVo.setIsDelete(musicInfo.getIsDelete());
        // 将音乐标签信息设置到MusicDetailsVo对象中
        musicDetailsVo.setLabelId(musicInfo.getLabelId());
        musicDetailsVo.setLabel(musicLabel.getLabel());

        if (musicDetailsVo.getIsDelete() == 1){
            return null;
        }

        // 返回封装好的音乐详细信息对象
        return musicDetailsVo;
    }

    /**
     * 随机查询音乐信息，返回给前端5条音乐信息（用于首页推荐歌曲）
     * @return List<MusicDetailsVo> 随机查询到的音乐详细信息列表
     */
    @Override
    public List<MusicDetailsVo> findRandMusic(Integer limit) {
        // 随机查询music_info表中的5条音乐信息
        List<MusicInfo> musicInfo = musicInfoMapper.findRandMusic(limit);
        // 查询music_label表中的所有音乐标签信息
        List<MusicLabel> musicLabelList = musicLabelMapper.findLabelList();

        // 将查询到的音乐信息和音乐标签信息转换成MusicDetailsVo对象列表
        return MusicDetailsConvert.convert(musicInfo, musicLabelList);
    }

    /*
     * 向音乐表中插入一条音乐数据
     * @param musicInfo 要插入的音乐信息对象
     * @return 插入操作的结果信息
     */
    @Override
    public String insertOneMusic(MusicInfo musicInfo) {
        // 检查音乐信息对象中是否包含所有必要字段
        if (musicInfo.getMusicImg() == null || musicInfo.getMusicUrl() == null
                || musicInfo.getMusicName() == null || musicInfo.getSinger() == null
                || musicInfo.getLabelId() == null || musicInfo.getMusicTime() == null) {
            return "新增失败，缺少必要字段"; // 如果缺少必要字段，返回失败信息
        }
        // 执行插入操作，并获取受影响的行数
        int result = musicInfoMapper.insertOneMusic(musicInfo);
        if (result > 0) { // 如果插入成功
            // 查询刚插入的音乐信息
            MusicInfo insertedMusicInfo = musicInfoMapper.findMusicById(musicInfo.getMusicId());
            // 返回成功信息以及插入的音乐信息
            return "新增成功" + insertedMusicInfo;
        } else { // 如果插入失败
            return "新增失败，请检查数据"; // 返回失败信息
        }
    }

    /**
     * 批量插入多条音乐数据
     * @param musicInfoList 要插入的音乐信息对象列表
     * @return 插入操作后的音乐信息列表
     */
    @Override
    public List<MusicInfo> insertManyMusic(List<MusicInfo> musicInfoList) {
        // 执行批量插入操作，并返回插入后的音乐信息列表
        return musicInfoMapper.insertManyMusic(musicInfoList);
    }


    public MusicInfo deleteMusicById(Integer musicId) {
        // 根据音乐ID查询原始音乐信息
        MusicInfo originalmusicInfo = musicInfoMapper.findMusicById(musicId);
        if (originalmusicInfo == null) { // 如果原始音乐信息不存在
            return null; // 返回null
        }

        // 执行删除操作，并获取受影响的行数
        int result = musicInfoMapper.deleteById(musicId);
        if (result > 0) { // 如果删除成功
            // 返回删除后的音乐信息
            return musicInfoMapper.findMusicById(musicId);
        }else { // 如果删除失败
            return null; // 返回null
        }
    }

    /**
     * 更新音乐信息
     * @param musicInfo 包含更新后信息的音乐信息对象
     * @return 更新后的音乐信息对象，如果更新失败则返回null
     */
    @Override
    public MusicInfo updateMusicById(MusicInfo musicInfo) {
        // 根据音乐ID查询原始音乐信息
        MusicInfo originalmusicInfo = musicInfoMapper.findMusicById(musicInfo.getMusicId());
        if (originalmusicInfo == null) { // 如果原始音乐信息不存在
            return null; // 返回null
        }

        // 执行更新操作，并获取受影响的行数
        int result = musicInfoMapper.updateMusicById(musicInfo);
        if (result > 0) { // 如果更新成功
            // 查询更新后的音乐信息
            MusicInfo updatedMusicInfo = musicInfoMapper.findMusicById(musicInfo.getMusicId());
            // 检查更新后的信息是否与传入的信息一致
            if (!originalmusicInfo.equals(musicInfo)) {
                // 如果不一致，返回传入的更新后的信息
                return musicInfo;
            } else {
                // 如果一致，返回null
                return null;
            }
        } else { // 如果更新失败
            return null; // 返回null
        }
    }

    @Override
    public List<MusicInfo> getMusicsByLabelId(int labelId) {
        return musicInfoMapper.selectMusicsByLabelId(labelId);
    }


    /**
     *  获取音乐列表按点击量降序排序
     *  @return List<MusicInfo>
     * */
    @Override
    public List<MusicInfo> getMusicsByClickCountDesc() {
        // 获取 click_count 降序排序的结果
        List<MusicCount> musicCounts = musicCountMapper.selectList(
                Wrappers.<MusicCount>lambdaQuery()
                        .orderByDesc(MusicCount::getClickCount)
                        .last("limit 10") // 限制返回结果的数量为10
                        .eq(MusicCount::getIsDelete, 0) // 确保只查询未删除的记录
        );

        // 提取 musicId 列表
        List<Integer> musicIds = musicCounts.stream()
                .map(MusicCount::getMusicId)
                .distinct()
                .collect(Collectors.toList());

        // 根据 musicId 列表查询 music_info 表，并确保返回的结果与 musicId 列表的顺序一致
        List<MusicInfo> musicInfos = musicInfoMapper.selectList(
                Wrappers.<MusicInfo>lambdaQuery().in(MusicInfo::getMusicId, musicIds).eq(MusicInfo::getIsDelete, 0)
        );

        // 根据 musicId 排序 musicInfos
        Map<Integer, MusicInfo> musicInfoMap = musicInfos.stream()
                .collect(Collectors.toMap(MusicInfo::getMusicId, info -> info));

        List<MusicInfo> sortedMusicInfos = musicIds.stream()
                .map(musicInfoMap::get)
                .collect(Collectors.toList());

        return sortedMusicInfos;
    }


}